#!/bin/sh

# These variables are automatically filled in by the configure script.
prefix="@prefix@"
exec_prefix="@exec_prefix@"
libdir="@libdir@"
includedir="@includedir@"
name="@PACKAGE_TARNAME@"
version="@PACKAGE_VERSION@"

gtest_ldflags="-L${libdir}"
gtest_libs="-l${name}"
gtest_cppflags="-I${includedir}"
gtest_cxxflags=""

show_usage()
{
  cat <<EOF
Usage: gtest-config [OPTIONS...]
EOF
}

show_help()
{
  show_usage
  cat <<EOF

The \`gtest-config' script provides access to the necessary compile and linking
flags to connect with Google C++ Testing framework. The installation queries
may only be issued one at a time, and may not be issued with any other types of
queries. The version queries and compiler flag queries may be combined as
desired but not mixed. Different version queries are always combined with "and"
logical semantics, and only the last of any particular query is used and all
previous ones ignored. All versions must be specified as a sequence of numbers
separated by periods. Compiler flag queries output the union of the sets of
flags when combined.

 Examples:
  gtest-config --min-version=1.0 || echo "Insufficient Google Test version."
  
  gcc \$(gtest-config --cppflags --cxxflags) -o foo.o -c foo.cpp
  gcc \$(gtest-config --ldflags --libs) -o foo foo.o

 Help:
  --usage                    brief usage information
  --help                     display this help message

 Installation Queries:
  --prefix                   installation prefix
  --exec-prefix              executable installation prefix
  --libdir                   library installation directory
  --includedir               header file installation directory
  --version                  the version of the INC installation

 Version Queries:
  --min-version=VERSION      return 0 if the version is at least VERSION
  --exact-version=VERSION    return 0 if the version is exactly VERSION
  --max-version=VERSION      return 0 if the version is at most VERSION

 Compilation Flag Queries:
  --cppflags                 compile flags specific to the C-like preprocessors
  --cxxflags                 compile flags appropriate for C++ programs
  --ldflags                  linker flags
  --libs                     libraries for linking

EOF
}

# This function bounds our version with a min and a max. It uses some clever
# POSIX-compliant variable expansion to portably do all the work in the shell
# and avoid any dependency on a particular "sed" implementation. Notable is
# that it will only ever compare the first 3 components of versions. Further
# components will be cleanly stripped off. All versions must be unadorned, so
# "v1.0" will *not* work. The minimum version must be in $1, and the max in
# $2.
check_versions()
{
  major_version=${version%%.*}
  minor_version="0"
  point_version="0"
  if test "${version#*.}" != "${version}"; then
    minor_version=${version#*.}
    minor_version=${minor_version%%.*}
  fi
  if test "${version#*.*.}" != "${version}"; then
    point_version=${version#*.*.}
    point_version=${point_version%%.*}
  fi

  min_version="$1"
  min_major_version=${min_version%%.*}
  min_minor_version="0"
  min_point_version="0"
  if test "${min_version#*.}" != "${min_version}"; then
    min_minor_version=${min_version#*.}
    min_minor_version=${min_minor_version%%.*}
  fi
  if test "${min_version#*.*.}" != "${min_version}"; then
    min_point_version=${min_version#*.*.}
    min_point_version=${min_point_version%%.*}
  fi

  max_version="$2"
  max_major_version=${max_version%%.*}
  max_minor_version="0"
  max_point_version="0"
  if test "${max_version#*.}" != "${max_version}"; then
    max_minor_version=${max_version#*.}
    max_minor_version=${max_minor_version%%.*}
  fi
  if test "${max_version#*.*.}" != "${max_version}"; then
    max_point_version=${max_version#*.*.}
    max_point_version=${max_point_version%%.*}
  fi

  test $(($major_version)) -lt $(($min_major_version)) && exit 1
  if test $(($major_version)) -eq $(($min_major_version)); then
    test $(($minor_version)) -lt $(($min_minor_version)) && exit 1
    if test $(($minor_version)) -eq $(($min_minor_version)); then
      test $(($point_version)) -lt $(($min_point_version)) && exit 1
    fi
  fi

  test $(($major_version)) -gt $(($max_major_version)) && exit 1
  if test $(($major_version)) -eq $(($max_major_version)); then
    test $(($minor_version)) -gt $(($max_minor_version)) && exit 1
    if test $(($minor_version)) -eq $(($max_minor_version)); then
      test $(($point_version)) -gt $(($max_point_version)) && exit 1
    fi
  fi

  exit 0
}

# Show the usage line when no arguments are specified.
if test $# -eq 0; then
  show_usage
  exit 1
fi

while test $# -gt 0; do
  case $1 in
    --usage)        show_usage;         exit 0;;
    --help)         show_help;          exit 0;;
    --prefix)       echo $prefix;       exit 0;;
    --exec-prefix)  echo $exec_prefix;  exit 0;;
    --libdir)       echo $libdir;       exit 0;;
    --includedir)   echo $includedir;   exit 0;;
    --version)      echo $version;      exit 0;;
    --min-version=*)
      do_check_versions=yes
      min_version=${1#--min-version=}
      ;;
    --max-version=*)
      do_check_versions=yes
      max_version=${1#--max-version=}
      ;;
    --exact-version=*)
      do_check_versions=yes
      exact_version=${1#--exact-version=}
      ;;
    --cppflags)     echo_cppflags=yes;;
    --cxxflags)     echo_cxxflags=yes;;
    --ldflags)      echo_ldflags=yes;;
    --libs)         echo_libs=yes;;

    # Everything else is an error
    *)              show_usage;         exit 1;;
  esac
  shift
done

# Do a version check if requested.
if test "$do_check_versions" = "yes"; then
  # Make sure we didn't receive a bad combination of parameters.
  test "$echo_cppflags" = "yes" && show_usage && exit 1
  test "$echo_cxxflags" = "yes" && show_usage && exit 1
  test "$echo_ldflags" = "yes"  && show_usage && exit 1
  test "$echo_libs" = "yes"     && show_usage && exit 1

  if test "$exact_version" != ""; then
    check_versions $exact_version $exact_version
    # unreachable
  else
    check_versions ${min_version:-0.0.0} ${max_version:-9999.9999.9999}
    # unreachable
  fi
fi

# Do the output in the correct order so that these can be used in-line of
# a compiler invocation.
output=""
test "$echo_cppflags" = "yes" && output="$output $gtest_cppflags"
test "$echo_cxxflags" = "yes" && output="$output $gtest_cxxflags"
test "$echo_ldflags" = "yes"  && output="$output $gtest_ldflags"
test "$echo_libs" = "yes"     && output="$output $gtest_libs"
echo $output

exit 0
